JavaScript-Code-Transformation: Ein umfassender Leitfaden zur Entwicklung von Babel-Plugins

JavaScript ist eine unglaublich vielseitige Sprache, die einen erheblichen Teil des Internets antreibt. Die kontinuierliche Weiterentwicklung von JavaScript mit häufig neu hinzukommenden Funktionen und Syntax stellt Entwickler jedoch vor Herausforderungen. Hier kommen Code-Transformations-Tools, insbesondere Babel, ins Spiel. Babel ermöglicht es Entwicklern, die neuesten JavaScript-Funktionen auch in Umgebungen zu verwenden, die diese noch nicht unterstützen. Im Kern wandelt Babel modernen JavaScript-Code in eine Version um, die Browser und andere Laufzeitumgebungen verstehen können. Das Verständnis, wie man benutzerdefinierte Babel-Plugins erstellt, befähigt Entwickler, diese Funktionalität zu erweitern, Code zu optimieren, Codierungsstandards durchzusetzen und sogar völlig neue JavaScript-Dialekte zu schaffen. Dieser Leitfaden bietet einen detaillierten Überblick über die Entwicklung von Babel-Plugins, der für Entwickler aller Erfahrungsstufen geeignet ist.

Warum Babel? Warum Plugins?

Babel ist ein JavaScript-Compiler, der modernen JavaScript-Code (ESNext) in eine abwärtskompatible Version von JavaScript (ES5) umwandelt, die in allen Browsern ausgeführt werden kann. Es ist ein unverzichtbares Werkzeug, um die Code-Kompatibilität über verschiedene Browser und Umgebungen hinweg sicherzustellen. Aber die Leistungsfähigkeit von Babel geht über die einfache Transpilierung hinaus; sein Plugin-System ist ein zentrales Merkmal.

• Kompatibilität: Nutzen Sie schon heute die neuesten JavaScript-Funktionen.
• Code-Optimierung: Verbessern Sie die Leistung und Größe des Codes.
• Durchsetzung des Programmierstils: Erzwingen Sie einheitliche Codierungspraktiken in Teams.
• Benutzerdefinierte Syntax: Experimentieren und implementieren Sie Ihre eigene JavaScript-Syntax.

Babel-Plugins ermöglichen es Entwicklern, den Code-Transformationsprozess anzupassen. Sie arbeiten auf einem abstrakten Syntaxbaum (AST), einer strukturierten Darstellung des JavaScript-Codes. Dieser Ansatz ermöglicht eine feingranulare Kontrolle darüber, wie der Code transformiert wird.

Den abstrakten Syntaxbaum (AST) verstehen

Der AST ist eine baumartige Darstellung Ihres JavaScript-Codes. Er zerlegt Ihren Code in kleinere, besser handhabbare Teile und ermöglicht es Babel (und Ihren Plugins), die Struktur des Codes zu analysieren und zu manipulieren. Der AST ermöglicht es Babel, verschiedene Sprachkonstrukte wie Variablen, Funktionen, Schleifen und mehr zu identifizieren und umzuwandeln.

Tools wie AST Explorer sind von unschätzbarem Wert, um zu verstehen, wie Code in einem AST dargestellt wird. Sie können JavaScript-Code in das Tool einfügen und seine entsprechende AST-Struktur sehen. Dies ist entscheidend für die Plugin-Entwicklung, da Sie diese Struktur navigieren und modifizieren müssen.

Betrachten Sie zum Beispiel den folgenden JavaScript-Code:

            const message = 'Hello, World!';
console.log(message);
            

              
                Copy
              
            
          

Seine AST-Darstellung könnte ungefähr so aussehen (vereinfacht):

            Program {
  body: [
    VariableDeclaration {
      kind: 'const',
      declarations: [
        VariableDeclarator {
          id: Identifier { name: 'message' },
          init: Literal { value: 'Hello, World!' }
        }
      ]
    },
    ExpressionStatement {
      expression: CallExpression {
        callee: MemberExpression {
          object: Identifier { name: 'console' },
          property: Identifier { name: 'log' }
        },
        arguments: [
          Identifier { name: 'message' }
        ]
      }
    }
  ]
}
            

              
                Copy
              
            
          

Jeder Knoten im AST repräsentiert ein bestimmtes Element im Code (z.B. `VariableDeclaration`, `Identifier`, `Literal`). Ihr Plugin wird diese Informationen verwenden, um den Code zu durchlaufen und zu modifizieren.

Einrichten Ihrer Babel-Plugin-Entwicklungsumgebung

Um zu beginnen, müssen Sie Ihre Entwicklungsumgebung einrichten. Dazu gehört die Installation von Node.js und npm (oder yarn). Anschließend können Sie ein neues Projekt erstellen und die notwendigen Abhängigkeiten installieren.

1. Erstellen Sie ein Projektverzeichnis:

            mkdir babel-plugin-example
cd babel-plugin-example
            

              
                Copy
              
            
          

2. Initialisieren Sie das Projekt:

            npm init -y
            

              
                Copy
              
            
          

3. Installieren Sie den Babel-Kern und Abhängigkeiten:

            npm install --save-dev @babel/core @babel/types
            

              
                Copy
              
            
          

• @babel/core: Die Kernbibliothek von Babel.
• @babel/types: Ein Hilfsprogramm zur Erstellung von AST-Knoten.

Sie können auch Plugins wie `@babel/preset-env` zum Testen installieren. Dieses Preset hilft bei der Umwandlung von ESNext-Code in ES5, ist aber für die grundlegende Plugin-Entwicklung nicht zwingend erforderlich.

            npm install --save-dev @babel/preset-env
            

              
                Copy
              
            
          

Erstellen Ihres ersten Babel-Plugins: Ein einfaches Beispiel

Lassen Sie uns ein einfaches Plugin erstellen, das am Anfang jeder Datei einen Kommentar hinzufügt. Dieses Beispiel demonstriert die grundlegende Struktur eines Babel-Plugins.

1. Erstellen Sie eine Plugin-Datei (z.B. my-babel-plugin.js):

            // my-babel-plugin.js
module.exports = function(babel) {
  const { types: t } = babel;

  return {
    name: 'add-comment',
    visitor: {
      Program(path) {
        path.unshiftContainer('body', t.addComment('leading', path.node, 'Dieser Code wurde von meinem Babel-Plugin transformiert'));
      }
    }
  };
};

            

              
                Copy
              
            
          

• module.exports: Diese Funktion erhält eine Babel-Instanz als Argument.
• t (@babel/types): Bietet Methoden zur Erstellung von AST-Knoten.
• name: Der Name des Plugins (zur Fehlersuche und Identifizierung).
• visitor: Ein Objekt, das Besucherfunktionen enthält. Jeder Schlüssel repräsentiert einen AST-Knotentyp (z.B. `Program`).
• Program(path): Diese Besucherfunktion wird ausgeführt, wenn Babel auf den `Program`-Knoten (die Wurzel des AST) trifft.
• path.unshiftContainer: Fügt einen AST-Knoten am Anfang eines Containers ein (in diesem Fall der `body` des `Program`).
• t.addComment: Erstellt einen führenden Kommentarknoten.

2. Testen Sie das Plugin: Erstellen Sie eine Testdatei (z.B. index.js):

            // index.js
const greeting = 'Hello, Babel!';
console.log(greeting);

            

              
                Copy
              
            
          

3. Konfigurieren Sie Babel (z.B. mit einer .babelrc.js-Datei):

            // .babelrc.js
module.exports = {
  plugins: ['./my-babel-plugin.js']
};

            

              
                Copy
              
            
          

4. Führen Sie Babel aus, um den Code zu transformieren:

            npx babel index.js -o output.js
            

              
                Copy
              
            
          

Dieser Befehl verarbeitet index.js mit Ihrem Plugin und gibt den transformierten Code in output.js aus.

5. Untersuchen Sie die Ausgabe (output.js):

            // Dieser Code wurde von meinem Babel-Plugin transformiert
const greeting = 'Hello, Babel!';
console.log(greeting);

            

              
                Copy
              
            
          

Sie sollten den Kommentar am Anfang des transformierten Codes sehen.

Tiefer Einblick in die Plugin-Struktur

Babel-Plugins verwenden das Besucher-Muster (Visitor Pattern), um den AST zu durchlaufen und den Code zu transformieren. Lassen Sie uns die Schlüsselkomponenten eines Plugins genauer betrachten.

• module.exports(babel): Die Hauptfunktion, die das Plugin exportiert. Sie erhält eine Babel-Instanz, die Ihnen Zugriff auf das types-Hilfsprogramm (t) und andere Babel-Funktionen gibt.
• name: Ein beschreibender Name für Ihr Plugin. Dies hilft bei der Fehlersuche und der Identifizierung des Plugins in der Babel-Konfiguration.
• visitor: Das Herzstück Ihres Plugins. Es ist ein Objekt, das Besuchermethoden für verschiedene AST-Knotentypen enthält.
• Besuchermethoden: Jede Methode im visitor-Objekt entspricht einem AST-Knotentyp (z.B. `Program`, `Identifier`, `CallExpression`). Wenn Babel auf einen Knoten dieses Typs trifft, ruft es die entsprechende Besuchermethode auf. Die Besuchermethode erhält ein `path`-Objekt, das den aktuellen Knoten repräsentiert und Methoden zum Durchlaufen und Manipulieren des AST bereitstellt.
• path-Objekt: Das `path`-Objekt ist zentral für die Plugin-Entwicklung. Es bietet eine Fülle von Methoden zur Navigation und Transformation des AST:

• path.node: Der aktuelle AST-Knoten.
• path.parent: Der übergeordnete Knoten des aktuellen Knotens.
• path.traverse(visitor): Durchläuft rekursiv die Kinder des aktuellen Knotens.
• path.replaceWith(newNode): Ersetzt den aktuellen Knoten durch einen neuen Knoten.
• path.remove(): Entfernt den aktuellen Knoten.
• path.insertBefore(newNode): Fügt einen neuen Knoten vor dem aktuellen Knoten ein.
• path.insertAfter(newNode): Fügt einen neuen Knoten nach dem aktuellen Knoten ein.
• path.findParent(callback): Findet den nächstgelegenen übergeordneten Knoten, der eine Bedingung erfüllt.
• path.getSibling(key): Ruft einen Geschwisterknoten ab.

Arbeiten mit @babel/types

Das Modul @babel/types bietet Hilfsprogramme zur Erstellung und Bearbeitung von AST-Knoten. Dies ist entscheidend für die Konstruktion von neuem Code und die Änderung bestehender Codestrukturen innerhalb Ihres Plugins. Die Funktionen in diesem Modul entsprechen den verschiedenen AST-Knotentypen.

Hier sind einige Beispiele:

• t.identifier(name): Erstellt einen Identifier-Knoten (z.B. einen Variablennamen).
• t.stringLiteral(value): Erstellt einen StringLiteral-Knoten.
• t.numericLiteral(value): Erstellt einen NumericLiteral-Knoten.
• t.callExpression(callee, arguments): Erstellt einen CallExpression-Knoten (z.B. einen Funktionsaufruf).
• t.memberExpression(object, property): Erstellt einen MemberExpression-Knoten (z.B. `object.property`).
• t.arrowFunctionExpression(params, body): Erstellt einen ArrowFunctionExpression-Knoten.

Beispiel: Erstellen einer neuen Variablendeklaration:

            const newDeclaration = t.variableDeclaration('const', [
  t.variableDeclarator(
    t.identifier('myNewVariable'),
    t.stringLiteral('Hello, world!')
  )
]);

            

              
                Copy
              
            
          

Praktische Plugin-Beispiele

Lassen Sie uns einige praktische Beispiele für Babel-Plugins untersuchen, um ihre Vielseitigkeit zu demonstrieren. Diese Beispiele zeigen gängige Anwendungsfälle und bieten Ausgangspunkte für Ihre eigene Plugin-Entwicklung.

1. Entfernen von Console-Logs

Dieses Plugin entfernt alle `console.log`-Anweisungen aus Ihrem Code. Dies kann bei Produktions-Builds äußerst hilfreich sein, um zu vermeiden, dass versehentlich Debugging-Informationen offengelegt werden.

            // remove-console-logs.js
module.exports = function(babel) {
  const { types: t } = babel;

  return {
    name: 'remove-console-logs',
    visitor: {
      CallExpression(path) {
        if (path.node.callee.type === 'MemberExpression' &&
            path.node.callee.object.name === 'console' &&
            path.node.callee.property.name === 'log') {
          path.remove();
        }
      }
    }
  };
};

            

              
                Copy
              
            
          

In diesem Plugin prüft der `CallExpression`-Visitor, ob der Funktionsaufruf eine `console.log`-Anweisung ist. Wenn ja, entfernt die `path.remove()`-Methode den gesamten Knoten.

2. Umwandeln von Template-Literalen in Verkettungen

Dieses Plugin wandelt Template-Literale (``) in String-Verkettungen mit dem `+`-Operator um. Dies ist nützlich für ältere JavaScript-Umgebungen, die Template-Literale nicht nativ unterstützen (obwohl Babel dies normalerweise automatisch erledigt).

            // template-literal-to-concat.js
module.exports = function(babel) {
  const { types: t } = babel;

  return {
    name: 'template-literal-to-concat',
    visitor: {
      TemplateLiteral(path) {
        const expressions = path.node.expressions;
        const quasis = path.node.quasis;
        let result = t.stringLiteral(quasis[0].value.raw);

        for (let i = 0; i < expressions.length; i++) {
          result = t.binaryExpression(
            '+',
            result,
            expressions[i]
          );
          result = t.binaryExpression(
            '+',
            result,
            t.stringLiteral(quasis[i + 1].value.raw)
          );
        }
        path.replaceWith(result);
      }
    }
  };
};

            

              
                Copy
              
            
          

Dieses Plugin verarbeitet die `TemplateLiteral`-Knoten. Es iteriert über die Ausdrücke und Quasis (String-Teile) und konstruiert die äquivalente Verkettung mit `t.binaryExpression`.

3. Hinzufügen von Copyright-Hinweisen

Dieses Plugin fügt am Anfang jeder Datei einen Copyright-Hinweis hinzu und demonstriert, wie Code an bestimmten Stellen eingefügt wird.

            // add-copyright-notice.js
module.exports = function(babel) {
  const { types: t } = babel;

  return {
    name: 'add-copyright-notice',
    visitor: {
      Program(path) {
        path.unshiftContainer('body', t.commentBlock(' Copyright (c) 2024 Ihr Unternehmen '));
      }
    }
  };
};

            

              
                Copy
              
            
          

Dieses Beispiel verwendet den `Program`-Visitor, um am Anfang der Datei einen mehrzeiligen Kommentarblock hinzuzufügen.

Fortgeschrittene Techniken der Plugin-Entwicklung

Über die Grundlagen hinaus gibt es fortgeschrittenere Techniken, um Ihre Babel-Plugin-Entwicklung zu verbessern.

• Plugin-Optionen: Ermöglichen Sie Benutzern, Ihr Plugin mit Optionen zu konfigurieren.
• Kontext: Greifen Sie auf den Babel-Kontext zu, um den Zustand zu verwalten oder asynchrone Operationen durchzuführen.
• Source Maps: Generieren Sie Source Maps, um transformierten Code auf den ursprünglichen Quellcode zurückzuführen.
• Fehlerbehandlung: Behandeln Sie Fehler elegant, um den Benutzern hilfreiches Feedback zu geben.

1. Plugin-Optionen

Plugin-Optionen ermöglichen es Benutzern, das Verhalten Ihres Plugins anzupassen. Sie definieren diese Optionen in der Hauptfunktion des Plugins.

            // plugin-with-options.js
module.exports = function(babel, options) {
  const { types: t } = babel;
  const { authorName = 'Unbekannter Autor' } = options;

  return {
    name: 'plugin-with-options',
    visitor: {
      Program(path) {
        path.unshiftContainer('body', t.commentBlock(` Copyright (c) 2024 ${authorName} `));
      }
    }
  };
};

            

              
                Copy
              
            
          

In diesem Beispiel akzeptiert das Plugin eine authorName-Option mit dem Standardwert 'Unbekannter Autor'. Benutzer konfigurieren das Plugin über die Konfigurationsdatei von Babel (.babelrc.js oder babel.config.js).

            // .babelrc.js
module.exports = {
  plugins: [[
    './plugin-with-options.js',
    { authorName: 'John Doe' }
  ]]
};

            

              
                Copy
              
            
          

2. Kontext

Babel stellt ein Kontextobjekt bereit, mit dem Sie den Zustand verwalten und Operationen durchführen können, die über mehrere Dateitransformationen hinweg bestehen bleiben. Dies ist nützlich für Aufgaben wie Caching oder das Sammeln von Statistiken.

Greifen Sie auf den Kontext über die Babel-Instanz zu, typischerweise beim Übergeben von Optionen an die Plugin-Funktion. Das `file`-Objekt enthält den Kontext, der für die aktuell transformierte Datei spezifisch ist.

            // plugin-with-context.js
module.exports = function(babel, options, dirname) {
  const { types: t } = babel;
  let fileCount = 0;

  return {
    name: 'plugin-with-context',
    pre(file) {
      // Läuft einmal pro Datei
      fileCount++;
      console.log(`Transformiere Datei: ${file.opts.filename}`);
    },
    visitor: {
      Program(path) {
        path.unshiftContainer('body', t.commentBlock(` Transformiert durch Plugin (Dateianzahl: ${fileCount})`));
      }
    },
    post(file) {
        // Läuft nach jeder Datei
        console.log(`Transformation abgeschlossen: ${file.opts.filename}`);
    }
  };
};

            

              
                Copy
              
            
          

Das obige Beispiel demonstriert die pre- und post-Hooks. Mit diesen Hooks können Sie Einrichtungs- und Aufräumarbeiten vor und nach der Verarbeitung einer Datei durchführen. Die Dateianzahl wird in `pre` erhöht. Hinweis: Das dritte Argument, `dirname`, gibt das Verzeichnis an, in dem sich die Konfigurationsdatei befindet, was für Dateioperationen hilfreich ist.

3. Source Maps

Source Maps sind für das Debuggen von transformiertem Code unerlässlich. Sie ermöglichen es Ihnen, den transformierten Code dem ursprünglichen Quellcode zuzuordnen, was das Debuggen erheblich erleichtert. Babel behandelt Source Maps automatisch, aber Sie müssen sie möglicherweise je nach Ihrem Build-Prozess konfigurieren.

Stellen Sie sicher, dass Source Maps in Ihrer Babel-Konfiguration aktiviert sind (normalerweise standardmäßig). Wenn Sie einen Bundler wie Webpack oder Parcel verwenden, kümmern sich diese in der Regel um die Generierung und Integration von Source Maps.

4. Fehlerbehandlung

Eine robuste Fehlerbehandlung ist entscheidend. Geben Sie aussagekräftige Fehlermeldungen aus, um Benutzern zu helfen, Probleme zu verstehen und zu beheben. Babel bietet Methoden zur Meldung von Fehlern.

            // plugin-with-error-handling.js
module.exports = function(babel) {
  const { types: t } = babel;

  return {
    name: 'plugin-with-error-handling',
    visitor: {
      Identifier(path) {
        if (path.node.name === 'invalidVariable') {
          path.traverse({})
          path.buildCodeFrameError('Ungültiger Variablenname: invalidVariable').loc.column;
          //throw path.buildCodeFrameError('Ungültiger Variablenname: invalidVariable');
        }
      }
    }
  };
};

            

              
                Copy
              
            
          

Verwenden Sie path.buildCodeFrameError(), um Fehlermeldungen zu erstellen, die den Ort des Fehlers im Quellcode enthalten, was es dem Benutzer erleichtert, ihn zu finden und zu beheben. Das Auslösen des Fehlers stoppt den Transformationsprozess und zeigt den Fehler in der Konsole an.

Testen Ihrer Babel-Plugins

Gründliche Tests sind unerlässlich, um sicherzustellen, dass Ihre Plugins korrekt funktionieren und kein unerwartetes Verhalten einführen. Sie können Unit-Tests verwenden, um zu überprüfen, ob Ihr Plugin den Code wie erwartet transformiert. Testen Sie eine Vielzahl von Szenarien, einschließlich gültiger und ungültiger Eingaben, um eine umfassende Abdeckung zu gewährleisten.

Es stehen mehrere Test-Frameworks zur Verfügung. Jest und Mocha sind beliebte Optionen. Babel bietet Hilfsfunktionen zum Testen von Plugins. Diese beinhalten oft den Vergleich des Eingabecodes mit dem erwarteten Ausgabecode nach der Transformation.

Beispiel mit Jest und @babel/core:

            // plugin-with-jest.test.js
const { transformSync } = require('@babel/core');
const plugin = require('./remove-console-logs');

const code = `
console.log('Hello');
const message = 'World';
console.log(message);
`;

const expected = `
const message = 'World';
`;

test('entfernt console.log-Anweisungen', () => {
  const { code: transformedCode } = transformSync(code, {
    plugins: [plugin]
  });
  expect(transformedCode.trim()).toBe(expected.trim());
});

            

              
                Copy
              
            
          

Dieser Test verwendet `transformSync` von @babel/core, um das Plugin auf eine Test-Eingabezeichenkette anzuwenden, und vergleicht dann das transformierte Ergebnis mit der erwarteten Ausgabe.

Veröffentlichen Ihrer Babel-Plugins

Sobald Sie ein nützliches Babel-Plugin entwickelt haben, können Sie es auf npm veröffentlichen, um es mit der Welt zu teilen. Die Veröffentlichung ermöglicht es anderen Entwicklern, Ihr Plugin einfach zu installieren und zu verwenden. Stellen Sie sicher, dass das Plugin gut dokumentiert ist und den Best Practices für die Paketierung und Verteilung folgt.

1. Erstellen Sie eine package.json-Datei: Diese enthält Informationen über Ihr Plugin (Name, Beschreibung, Version usw.). Achten Sie darauf, Schlüsselwörter wie 'babel-plugin', 'javascript' und andere hinzuzufügen, um die Auffindbarkeit zu verbessern.
2. Richten Sie ein GitHub-Repository ein: Verwalten Sie den Code Ihres Plugins in einem öffentlichen oder privaten Repository. Dies ist entscheidend für die Versionskontrolle, Zusammenarbeit und zukünftige Updates.
3. Melden Sie sich bei npm an: Verwenden Sie den Befehl `npm login`.
4. Veröffentlichen Sie das Plugin: Verwenden Sie den Befehl `npm publish` in Ihrem Projektverzeichnis.

Best Practices und Überlegungen

• Lesbarkeit und Wartbarkeit: Schreiben Sie sauberen, gut dokumentierten Code. Verwenden Sie einen einheitlichen Programmierstil.
• Leistung: Berücksichtigen Sie die Leistungsauswirkungen Ihres Plugins, insbesondere bei großen Codebasen. Vermeiden Sie unnötige Operationen.
• Kompatibilität: Stellen Sie sicher, dass Ihr Plugin mit verschiedenen Versionen von Babel und JavaScript-Umgebungen kompatibel ist.
• Dokumentation: Bieten Sie eine klare und umfassende Dokumentation, einschließlich Beispielen und Konfigurationsoptionen. Eine gute README-Datei ist unerlässlich.
• Tests: Schreiben Sie umfassende Tests, um alle Funktionalitäten Ihres Plugins abzudecken und Regressionen zu verhindern.
• Versionierung: Befolgen Sie semantische Versionierung (SemVer), um die Releases Ihres Plugins zu verwalten.
• Community-Beiträge: Seien Sie offen für Beiträge aus der Community, um Ihr Plugin zu verbessern.
• Sicherheit: Bereinigen und validieren Sie alle vom Benutzer bereitgestellten Eingaben, um potenzielle Sicherheitslücken zu vermeiden.
• Lizenz: Fügen Sie eine Lizenz hinzu (z.B. MIT, Apache 2.0), damit andere Ihr Plugin verwenden und dazu beitragen können.

Fazit

Die Entwicklung von Babel-Plugins eröffnet JavaScript-Entwicklern weltweit eine riesige Welt der Anpassungsmöglichkeiten. Durch das Verständnis des AST und der verfügbaren Werkzeuge können Sie leistungsstarke Tools erstellen, um Ihre Arbeitsabläufe zu verbessern, Codierungsstandards durchzusetzen, Code zu optimieren und neue JavaScript-Syntaxen zu erforschen. Die in diesem Leitfaden bereitgestellten Beispiele bieten eine solide Grundlage. Denken Sie daran, beim Erstellen Ihrer eigenen Plugins auf Tests, Dokumentation und Best Practices zu setzen. Diese Reise vom Anfänger zum Experten ist ein fortlaufender Prozess. Kontinuierliches Lernen und Experimentieren sind der Schlüssel zur Beherrschung der Babel-Plugin-Entwicklung und zum Beitrag zum sich ständig weiterentwickelnden JavaScript-Ökosystem. Beginnen Sie zu experimentieren, zu erforschen und zu bauen – Ihre Beiträge werden sicherlich Entwicklern weltweit zugutekommen.